package org.dxy.trigger.http;

import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.dxy.api.dto.param.CreateProcessParamRequest;
import org.dxy.api.dto.param.UpdateProcessParamRequest;
import org.dxy.api.response.R;
import org.dxy.infrastructure.persistent.db.mybatispuls.po.ProcessParamRequirementPo;
import org.dxy.trigger.http.service.ProcessParamApplicationService;
import org.springdoc.core.annotations.ParameterObject;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;

import java.util.List;

/**
 * @description: 工序参数配置控制器
 * @author: dxy
 * @createTime: 2025/1/21
 */
@Slf4j
@RestController
@RequestMapping("/api/process-param")
@RequiredArgsConstructor
public class ProcessParamController {
    
    private final ProcessParamApplicationService processParamApplicationService;

    /**
     * 创建工序参数配置
     * @param dto 工序参数配置创建请求DTO
     * @return 操作结果
     */
    @PostMapping("/create")
    public R<Long> create(@Validated @RequestBody CreateProcessParamRequest dto) {
        log.info("创建工序参数配置请求 - 工序ID: {}, 参数定义ID: {}", dto.getProcessId(), dto.getParamDefinitionId());
        
        try {
            R<Long> result = processParamApplicationService.create(dto);
            if (result.isOk()) {
                log.info("工序参数配置创建成功 - 工序ID: {}, 参数定义ID: {}, ID: {}", 
                        dto.getProcessId(), dto.getParamDefinitionId(), result.getData());
            } else {
                log.warn("工序参数配置创建失败 - 工序ID: {}, 参数定义ID: {}, 错误信息: {}", 
                        dto.getProcessId(), dto.getParamDefinitionId(), result.getMsg());
            }
            return result;
        } catch (Exception e) {
            log.error("工序参数配置创建异常 - 工序ID: {}, 参数定义ID: {}", 
                    dto.getProcessId(), dto.getParamDefinitionId(), e);
            return R.fail("工序参数配置创建失败: " + e.getMessage());
        }
    }

    /**
     * 更新工序参数配置
     * @param dto 工序参数配置更新请求DTO
     * @return 操作结果
     */
    @PutMapping("/update")
    public R<Void> update(@Validated @RequestBody UpdateProcessParamRequest dto) {
        log.info("更新工序参数配置请求 - ID: {}", dto.getId());
        
        try {
            R<Void> result = processParamApplicationService.update(dto);
            if (result.isOk()) {
                log.info("工序参数配置更新成功 - ID: {}", dto.getId());
            } else {
                log.warn("工序参数配置更新失败 - ID: {}, 错误信息: {}", dto.getId(), result.getMsg());
            }
            return result;
        } catch (Exception e) {
            log.error("工序参数配置更新异常 - ID: {}", dto.getId(), e);
            return R.fail("工序参数配置更新失败: " + e.getMessage());
        }
    }

    /**
     * 分页查询工序参数配置列表
     * @param page 分页参数
     * @param query 查询条件
     * @return 分页的工序参数配置列表
     */
    @GetMapping("/list")
    public R<Page<ProcessParamRequirementPo>> list(
            @ParameterObject Page<ProcessParamRequirementPo> page,
            @ParameterObject ProcessParamRequirementPo query) {
        log.info("分页查询工序参数配置列表 - 页码: {}, 每页大小: {}", page.getCurrent(), page.getSize());
        
        try {
            R<Page<ProcessParamRequirementPo>> result = processParamApplicationService.list(page, query);
            if (result.isOk()) {
                log.info("工序参数配置列表查询成功 - 总数: {}", result.getData().getTotal());
            }
            return result;
        } catch (Exception e) {
            log.error("工序参数配置列表查询异常", e);
            return R.fail("工序参数配置列表查询失败: " + e.getMessage());
        }
    }

    /**
     * 查询工序参数配置详情
     * @param id 工序参数配置ID
     * @return 工序参数配置详情
     */
    @GetMapping("/{id}")
    public R<ProcessParamRequirementPo> getById(@PathVariable Long id) {
        log.info("查询工序参数配置详情 - ID: {}", id);
        
        if (id == null || id <= 0) {
            log.warn("无效的工序参数配置ID: {}", id);
            return R.fail("工序参数配置ID不能为空且必须为正整数");
        }
        
        try {
            R<ProcessParamRequirementPo> result = processParamApplicationService.getById(id);
            if (result.isOk()) {
                log.info("工序参数配置详情查询成功 - ID: {}", id);
            } else {
                log.warn("工序参数配置详情查询失败 - ID: {}, 错误信息: {}", id, result.getMsg());
            }
            return result;
        } catch (Exception e) {
            log.error("工序参数配置详情查询异常 - ID: {}", id, e);
            return R.fail("工序参数配置详情查询失败: " + e.getMessage());
        }
    }

    /**
     * 根据工序ID查询参数配置列表
     * @param processId 工序ID
     * @return 工序参数配置列表
     */
    @GetMapping("/process/{processId}")
    public R<List<ProcessParamRequirementPo>> getByProcessId(@PathVariable Long processId) {
        log.info("根据工序ID查询参数配置列表 - 工序ID: {}", processId);
        
        if (processId == null || processId <= 0) {
            log.warn("无效的工序ID: {}", processId);
            return R.fail("工序ID不能为空且必须为正整数");
        }
        
        try {
            R<List<ProcessParamRequirementPo>> result = processParamApplicationService.getByProcessId(processId);
            if (result.isOk()) {
                log.info("根据工序ID查询参数配置列表成功 - 工序ID: {}, 数量: {}", processId, result.getData().size());
            } else {
                log.warn("根据工序ID查询参数配置列表失败 - 工序ID: {}, 错误信息: {}", processId, result.getMsg());
            }
            return result;
        } catch (Exception e) {
            log.error("根据工序ID查询参数配置列表异常 - 工序ID: {}", processId, e);
            return R.fail("根据工序ID查询参数配置列表失败: " + e.getMessage());
        }
    }

    /**
     * 根据参数定义ID查询工序参数配置列表
     * @param paramDefinitionId 参数定义ID
     * @return 工序参数配置列表
     */
    @GetMapping("/param-definition/{paramDefinitionId}")
    public R<List<ProcessParamRequirementPo>> getByParamDefinitionId(@PathVariable Long paramDefinitionId) {
        log.info("根据参数定义ID查询工序参数配置列表 - 参数定义ID: {}", paramDefinitionId);
        
        if (paramDefinitionId == null || paramDefinitionId <= 0) {
            log.warn("无效的参数定义ID: {}", paramDefinitionId);
            return R.fail("参数定义ID不能为空且必须为正整数");
        }
        
        try {
            R<List<ProcessParamRequirementPo>> result = processParamApplicationService.getByParamDefinitionId(paramDefinitionId);
            if (result.isOk()) {
                log.info("根据参数定义ID查询工序参数配置列表成功 - 参数定义ID: {}, 数量: {}", 
                        paramDefinitionId, result.getData().size());
            } else {
                log.warn("根据参数定义ID查询工序参数配置列表失败 - 参数定义ID: {}, 错误信息: {}", 
                        paramDefinitionId, result.getMsg());
            }
            return result;
        } catch (Exception e) {
            log.error("根据参数定义ID查询工序参数配置列表异常 - 参数定义ID: {}", paramDefinitionId, e);
            return R.fail("根据参数定义ID查询工序参数配置列表失败: " + e.getMessage());
        }
    }

    /**
     * 查询必填参数配置
     * @param processId 工序ID（可选）
     * @return 必填参数配置列表
     */
    @GetMapping("/required")
    public R<List<ProcessParamRequirementPo>> getRequiredParams(
            @RequestParam(required = false) Long processId) {
        log.info("查询必填参数配置 - 工序ID: {}", processId);
        
        try {
            R<List<ProcessParamRequirementPo>> result = processParamApplicationService.getRequiredParams(processId);
            if (result.isOk()) {
                log.info("查询必填参数配置成功 - 工序ID: {}, 数量: {}", processId, result.getData().size());
            }
            return result;
        } catch (Exception e) {
            log.error("查询必填参数配置异常 - 工序ID: {}", processId, e);
            return R.fail("查询必填参数配置失败: " + e.getMessage());
        }
    }

    /**
     * 批量创建工序参数配置
     * @param dtoList 工序参数配置创建请求DTO列表
     * @return 操作结果
     */
    @PostMapping("/batch-create")
    public R<List<Long>> batchCreate(@Validated @RequestBody List<CreateProcessParamRequest> dtoList) {
        log.info("批量创建工序参数配置请求 - 数量: {}", dtoList.size());
        
        if (dtoList == null || dtoList.isEmpty()) {
            log.warn("批量创建请求参数无效: 配置列表为空");
            return R.fail("工序参数配置列表不能为空");
        }
        
        if (dtoList.size() > 100) {
            log.warn("批量创建请求参数无效: 一次创建的配置数量过多 {}", dtoList.size());
            return R.fail("一次最多只能创建100个工序参数配置");
        }
        
        try {
            R<List<Long>> result = processParamApplicationService.batchCreate(dtoList);
            if (result.isOk()) {
                log.info("批量创建工序参数配置成功 - 创建数量: {}", result.getData().size());
            } else {
                log.warn("批量创建工序参数配置失败 - 错误信息: {}", result.getMsg());
            }
            return result;
        } catch (Exception e) {
            log.error("批量创建工序参数配置异常", e);
            return R.fail("批量创建工序参数配置失败: " + e.getMessage());
        }
    }

    /**
     * 删除工序参数配置
     * @param id 工序参数配置ID
     * @return 操作结果
     */
    @DeleteMapping("/{id}")
    public R<Void> delete(@PathVariable Long id) {
        log.info("删除工序参数配置请求 - ID: {}", id);
        
        if (id == null || id <= 0) {
            log.warn("无效的工序参数配置ID: {}", id);
            return R.fail("工序参数配置ID不能为空且必须为正整数");
        }
        
        try {
            R<Void> result = processParamApplicationService.delete(id);
            if (result.isOk()) {
                log.info("工序参数配置删除成功 - ID: {}", id);
            } else {
                log.warn("工序参数配置删除失败 - ID: {}, 错误信息: {}", id, result.getMsg());
            }
            return result;
        } catch (Exception e) {
            log.error("工序参数配置删除异常 - ID: {}", id, e);
            return R.fail("工序参数配置删除失败: " + e.getMessage());
        }
    }

    /**
     * 批量删除工序参数配置
     * @param ids 工序参数配置ID列表
     * @return 操作结果
     */
    @DeleteMapping("/batch")
    public R<Void> batchDelete(@RequestBody List<Long> ids) {
        log.info("批量删除工序参数配置请求 - ID列表: {}", ids);
        
        if (ids == null || ids.isEmpty()) {
            log.warn("批量删除请求参数无效: ID列表为空");
            return R.fail("工序参数配置ID列表不能为空");
        }
        
        // 验证ID列表中的每个ID都是有效的正整数
        for (Long id : ids) {
            if (id == null || id <= 0) {
                log.warn("批量删除请求参数无效: 包含无效的工序参数配置ID {}", id);
                return R.fail("工序参数配置ID列表中包含无效的ID: " + id);
            }
        }
        
        if (ids.size() > 100) {
            log.warn("批量删除请求参数无效: 一次删除的配置数量过多 {}", ids.size());
            return R.fail("一次最多只能删除100个工序参数配置");
        }
        
        try {
            R<Void> result = processParamApplicationService.batchDelete(ids);
            if (result.isOk()) {
                log.info("批量删除工序参数配置成功 - 删除数量: {}", ids.size());
            } else {
                log.warn("批量删除工序参数配置失败 - ID列表: {}, 错误信息: {}", ids, result.getMsg());
            }
            return result;
        } catch (Exception e) {
            log.error("批量删除工序参数配置异常 - ID列表: {}", ids, e);
            return R.fail("批量删除工序参数配置失败: " + e.getMessage());
        }
    }

    /**
     * 根据工序ID删除所有参数配置
     * @param processId 工序ID
     * @return 操作结果
     */
    @DeleteMapping("/process/{processId}")
    public R<Void> deleteByProcessId(@PathVariable Long processId) {
        log.info("根据工序ID删除所有参数配置请求 - 工序ID: {}", processId);
        
        if (processId == null || processId <= 0) {
            log.warn("无效的工序ID: {}", processId);
            return R.fail("工序ID不能为空且必须为正整数");
        }
        
        try {
            R<Void> result = processParamApplicationService.deleteByProcessId(processId);
            if (result.isOk()) {
                log.info("根据工序ID删除所有参数配置成功 - 工序ID: {}", processId);
            } else {
                log.warn("根据工序ID删除所有参数配置失败 - 工序ID: {}, 错误信息: {}", processId, result.getMsg());
            }
            return result;
        } catch (Exception e) {
            log.error("根据工序ID删除所有参数配置异常 - 工序ID: {}", processId, e);
            return R.fail("根据工序ID删除所有参数配置失败: " + e.getMessage());
        }
    }
}